#include "Elfe.h"

using namespace std;
using namespace boost::assign;

const unsigned int Elfe::ens = 5;

const unsigned int Elfe::nbr_comp = 6;

const vector< vector< unsigned int> > Elfe::ensemble_racial =
  list_of< vector< unsigned int > >
  ( list_of( 3)( 6)(19)(11)(10) )      // aquatiques
  ( list_of(14)( 8)(11)(10)( 6)(16) )  // gris
  ( list_of( 8)(11)(10)( 1)( 6) )      // drows
  ( list_of(14)( 8)(11)(10)( 6)( 18) ) // sylvestre  
  ( list_of(14)( 8)(11)(10)( 6)(16));  // haut elfe


const unsigned int Elfe::taille = 19;

/**
 * Contient les capacités, puis les ensembles raciaux, à la fin.
 */
const vector< ListCapa > Elfe::Liste = list_of
  (ListCapa("Capacités magiques"               , 15))
  (ListCapa("Compagnion"                       , 10))
  (ListCapa("Conférer la respiration aquatique", 10))
  (ListCapa("Dextérité renforcée"              , 20))
  (ListCapa("Faibles besoins de sommeil"       ,  5))
  (ListCapa("Furtivité"                        , 10))
  (ListCapa("Identification de la magie"       , 10))
  (ListCapa("Infravision"                      , 10))
  (ListCapa("Langage des plantes"              , 10))
  (ListCapa("Portes secrètes"                  ,  5))
  (ListCapa("Résistance aux charmes et sommeil", 10))
  (ListCapa("Résistance à la chaleur"          ,  5))
  (ListCapa("Résistance au froid"              ,  5))
  (ListCapa("Talent pour les arcs"             ,  5))
  (ListCapa("Talent pour les dagues"           ,  5))
  (ListCapa("Talent pour les épées"            ,  5))
  (ListCapa("Talent pour les javelots"         ,  5))
  (ListCapa("Talent pour les lances"           ,  5))
  (ListCapa("Talent pour les tridents"         ,  5))
  (ListCapa("Elfe aquatique"                   , 40))
  (ListCapa("Elfe gris"                        , 45))
  (ListCapa("Elfe Noir"                        , 45))
  (ListCapa("Elfe sylvestre"                   , 40))
  (ListCapa("Haut-Elfe"                        , 40));

/**
 * Contient la liste des ensembles raciaux..
 */
const vector< ListCapa > Elfe::Ensembles = list_of
  (ListCapa("Elfe aquatique"                   , 40))
  (ListCapa("Elfe gris"                        , 45))
  (ListCapa("Elfe Noir"                        , 45))
  (ListCapa("Elfe sylvestre"                   , 40))
  (ListCapa("Haut-Elfe"                        , 40));

const vector< Prerequis > Elfe::Limites = list_of
  (Prerequis(1,  6, 18))
  (Prerequis(2,  7, 18))
  (Prerequis(3,  8, 18))
  (Prerequis(5,  8, 18));

/**
 * Constructeur simplifié, qui remplit simplement le conteneur des capacités.
 * Il est utilisé lors de la lecture d'un fichier XML.
 * @param cap conteneur des capacité
 */
Elfe::Elfe(vector<unsigned int> cap)
  :Race("Elfe")
{
  ptrCapa      = &Liste;
  ptrNbrCapa   = &taille;
  ptrEns       = &ensemble_racial;
  ptrNbrEns    = &ens;
  ptrMaxEns    = &nbr_comp;
  ptrNomEns    = &Ensembles;
  ptrPreRequis = &Limites;

  capacites.assign( cap.begin(), cap.end() );
}

/**
 * Constructeur usuel, qui permet de créer un Elfe en sélectionnant
 * ses capacités.
 * @param PP nombre de pp, passé en argument afin de pouvoir récupéré les
 * pp non dépensé
 */
Elfe::Elfe(unsigned int& PP)
  :Race("Elfe"), bonus_dext(false)
{
  ptrCapa      = &Liste;
  ptrNbrCapa   = &taille;
  ptrEns       = &ensemble_racial;
  ptrNbrEns    = &ens;
  ptrMaxEns    = &nbr_comp;
  ptrNomEns    = &Ensembles;
  ptrPreRequis = &Limites;

  blank() << setfill('*') << setw(56) << '*' << endreq;
  blank() << "Création d'un elfe" << endl << endreq;

  PP += 45;
  construitRace( PP );
  
//   unsigned int nbr(0), taille(24);
//   bool test(true), deja_pris, encore(false);
//   PP = 45;
//   do
//     {
//       blank() << "Tu as 45 pp à dépenser" << endreq;
//       for (unsigned int i(0); i<taille; i++)
// 	blank() << i+1 << ' ' << (Liste[i].Capa)
// 		    << " (" << Liste[i].Cout << " pp)" << endreq;
//       blank() << taille+1 << " Aucune" << endreq;
//       blank() << "Choisir les capacités raciales" << endreq;
//       while(test)
// 	{
// 	  nbr = demanderUnsignedBorne("("+ecrireString(PP)+" pp restants ",
// 					1, taille + 1);
// 	  if (nbr == taille+1)
// 	    test = false;
// 	  else
// 	    {
// 	      if (PP >= Liste[nbr-1].Cout)
// 		{
// 		  PP -= Liste[nbr-1].Cout;
// 		  if (nbr<20)
// 		    {
// 		      deja_pris = safePushBack(&capacites, nbr - 1);
// 		      if (deja_pris)
// 			warning() << "Déjà sélectionné" << endreq;
// 		      else
// 			{
// 			  capacites.push_back(nbr-1);
// 			  blank() << "Capacité choisie : "
// 				      << (Liste[nbr-1].Capa) << endreq;
// 			}
// 		      if (nbr == 1)
// 			bonus_dext = true;
// 		    }
// 		  else
// 		    {
// 		      blank() << "Achat de l'ensemble racial : "
// 				  << (Liste[nbr-1].Capa) << endreq;
// 		      for (unsigned int i(0); i < nbr_comp; i++)
// 			{
// 			  if (ensemble_racial[nbr-20][i] != 0)
// 			    capacites.push_back(ensemble_racial[nbr-20][i]-1);
// 			}
// 		    }
// 		}
// 	      else
// 		blank() << "Pas assez de pp" << endreq;
// 	    }
//     }
      
//       afficheInfo();
//       blank() << endl <<  "1 pour continuer, 2 pour recommencer" << endreq;
//       nbr = demanderUnsignedBorne("Choix ", 1, 2);
//       if (nbr == 2)
// 	{
// 	  PP = 45;
// 	  capacites.clear();
// 	  test = true;
// 	  encore = true;
// 	  blank() << endreq;
// 	}
//       else
// 	encore = false;
//     }
//   while(encore);
  
  blank() << endl << setfill('*') << setw(56) << '*' << endreq;
}

Elfe::Elfe()
  :Race("Elfe")
{
  ptrCapa      = &Liste;
  ptrNbrCapa   = &taille;
  ptrEns       = &ensemble_racial;
  ptrNbrEns    = &ens;
  ptrMaxEns    = &nbr_comp;
  ptrNomEns    = &Ensembles;
  ptrPreRequis = &Limites;
}

/**
 * Destructeur, ne fait rien de spécial.
 */
Elfe::~Elfe()
{}

/**
 * Les Elfes ont +1 en Dextérité, -1 en Constitution.
 * La capacité "Dextérité renforcée" leur permet de gagner encore +1 en
 * Dextérité (pour 20 pp).
 * @param tab traits du personnage
 */
void Elfe::appliquerAjustements(unsigned int tab[7])
{
  tab[1]++;
  tab[2]--;
  if (bonus_dext)
    tab[1]++;
}

// /**
//  * Affiche la race et les capacités
//  */
// void Elfe::affiche_info(ostream& os)
// {
//   os << "Race : " << Type << endreq;
//   for (unsigned int i(0); i<capacites.size(); i++)
//     os << (Liste[capacites[i]].Capa) << endreq;
// }

// /**
//  * Retrouve la capacité voulue.
//  * @param i le numéro de la capacité
//  * @return la capacité (string)
//  */
// string Elfe::get_capacite(const unsigned int& i) const
// {
//   return (Liste[get_capa(i)].Capa);
// }

// void Elfe::get_capacites(unsigned int& nbr, vector<ListCapa> &capa) const
// {
//   nbr = taille;

//   capa.clear();

//   for (unsigned int i(0); i < taille; i++)
//     capa.push_back(Liste[i]);
// }

// void Elfe::get_ensemble_racial(unsigned int& nbr, unsigned int& max) const
// {
//   nbr = ens;
//   max = nbr_comp;
// }

// const unsigned int* Elfe::get_ensemble_racial(const unsigned int& nbr) const
// {
//   return &ensemble_racial[nbr][0];
// }
